#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<thread>
#include <ctime>
#include <ratio>
#include <chrono>
using namespace std;

// int main()
// {
// 	FILE* fout = fopen("Test.txt", "r");
// 	cout << fout << endl;
// 	cout << errno << endl;
// 	perror("fopen fail");

// 	return 0;
// }



// double Division(int a, int b)
// {
//     // 当b == 0时抛出异常
//     if (b == 0)
//         throw "Division by zero condition!";
//     else
//         return ((double)a / (double)b);
// }

// void Func()
// {
//     int len, time;
//     cin >> len >> time;
//     cout << Division(len, time) << endl;
// }

// int main()
// {
//     try {
//         Func();
//     }
//     catch (const char* errmsg) {
//         cout << errmsg << endl;
//     }
//     catch(...){
//         cout<<"unkown exception"<<endl;
//     }

//     return 0;
// }





// double Division(int a, int b)
// {
// 	// 当b == 0时抛出异常
// 	if (b == 0)
// 	{
// 		string s("Division by zero condition!");
// 		throw s;
// 	}
// 	else
// 	{
// 		return ((double)a / (double)b);
// 	}
// }
// void Func()
// {
// 	int len, time;
// 	cin >> len >> time;
// 	try
// 	{
// 		cout << Division(len, time) << endl;
// 	}
// 	catch (size_t x)
// 	{
// 		cout << x << endl;
// 	}
// 	cout << "xxxxxxxxxxxxxxxxxxxxx" << endl;
// }
// int main()
// {
// 	while (1)
// 	{
// 		try
// 		{
// 			Func();
// 		}
// 		catch (const string& errmsg)
// 		{
// 			cout << errmsg << endl;
// 		}
// 		catch (...)
// 		{
// 			cout << "unkown exception" << endl;
// 		}
// 	}
// 	return 0;
// }




// double Division(int a, int b)
// {
// 	// 当b == 0时抛出异常
// 	if (b == 0)
// 	{
// 		string s("Division by zero condition!");
// 		throw s;
// 	}
// 	else
// 	{
// 		return ((double)a / (double)b);
// 	}
// }
// void Func()
// {
// 	int len, time;
// 	cin >> len >> time;

// 	try
// 	{
// 		cout << Division(len, time) << endl;
// 	}
// 	catch (size_t x)
// 	{
// 		cout << x << endl;
// 	}
// 	catch (const char* errmsg)
// 	{
// 		cout << errmsg << endl;
// 	}
// 	cout << "xxxxxxxxxxxxxxxxxxxxx" << endl;
// }
// int main()
// {
// 	while (1)
// 	{
// 		try
// 		{
// 			Func();
// 		}
// 		catch (const string& errmsg)
// 		{
// 			cout << errmsg << endl;
// 		}
// 		catch (...)
// 		{
// 			cout << "unkown exception" << endl;
// 		}
// 	}

// 	return 0;
// }





// 服务器开发中通常使用的异常继承体系
// class Exception
// {
// public:
// 	Exception(const string& errmsg, int id)
// 		:_errmsg(errmsg)
// 		, _id(id)
// 	{}

// 	virtual string what() const
// 	{
// 		return _errmsg;
// 	}

// 	int getid() const
// 	{
// 		return _id;
// 	}

// protected:
// 	string _errmsg;
// 	int _id;
// };

// class SqlException : public Exception
// {
// public:
// 	SqlException(const string& errmsg, int id, const string& sql)
// 		:Exception(errmsg, id)
// 		, _sql(sql)
// 	{}

// 	virtual string what() const
// 	{
// 		string str = "SqlException:";
// 		str += _errmsg;
// 		str += "->";
// 		str += _sql;
// 		return str;
// 	}
// private:
// 	const string _sql;
// };

// class CacheException : public Exception
// {
// public:
// 	CacheException(const string& errmsg, int id)
// 		:Exception(errmsg, id)
// 	{}

// 	virtual string what() const
// 	{
// 		string str = "CacheException:";
// 		str += _errmsg;
// 		return str;
// 	}
// };

// class HttpServerException : public Exception
// {
// public:
// 	HttpServerException(const string& errmsg, int id, const string& type)
// 		:Exception(errmsg, id)
// 		, _type(type)
// 	{}

// 	virtual string what() const
// 	{
// 		string str = "HttpServerException:";
// 		str += _type;
// 		str += ":";
// 		str += _errmsg;
// 		return str;
// 	}

// private:
// 	const string _type;
// };

// void SQLMgr()
// {
// 	if (rand() % 7 == 0)
// 	{
// 		throw SqlException("权限不足", 100, "select * from name = '张三'");
// 	}
	
// 	cout << "调用成功" << endl;
// }

// void CacheMgr()
// {
// 	if (rand() % 5 == 0)
// 	{
// 		throw CacheException("权限不足", 100);
// 	}
// 	else if (rand() % 6 == 0)
// 	{
// 		throw CacheException("数据不存在", 101);
// 	}
// 	SQLMgr();
// }

// void seedmsg(const string& s)
// {
// 	//cout << "void seedmsg(const string& s)" << endl;

// 	//throw HttpServerException("网络不稳定，发送失败", 102, "put");

// 	if (rand() % 2 == 0)
// 	{ 
// 		throw HttpServerException("网络不稳定，发送失败", 102, "put");
// 	}
// 	else if (rand() % 3 == 0)
// 	{
// 		throw HttpServerException("你已经不是对象的好友，发送失败", 103, "put");
// 	}
// 	else
// 	{
// 		cout << "发送成功" << endl;
// 	}
// }

// void HttpServer()
// {
// 	/*if (rand() % 3 == 0)
// 	{
// 		throw HttpServerException("请求资源不存在", 100, "get");
// 	}
// 	else if (rand() % 4 == 0)
// 	{
// 		throw HttpServerException("权限不足", 101, "post");
// 	}*/
	
// 	// 失败以后，再重试3次
// 	for (size_t i = 0; i < 4; i++)
// 	{
// 		try
// 		{
// 			seedmsg("今天一起看电影吧");
// 			break;
// 		}
// 		catch (const Exception& e)
// 		{
// 			if (e.getid() == 102)
// 			{
// 				if (i == 3)
// 					throw e;

// 				cout << "开始第" << i+1 << "重试" << endl;
// 			}
// 			else
// 			{
// 				throw e;
// 			}
// 		}
// 	}
	

// 	CacheMgr();
// }


// int main()
// {
// 	srand(time(0));

// 	while (1)
// 	{
// 		this_thread::sleep_for(chrono::seconds(1));

// 		try 
// 		{
// 			HttpServer();
// 		}
// 		catch (const Exception& e) // 这里捕获父类对象就可以
// 		{
// 			using std::chrono::system_clock;
// 			// 多态
// 			system_clock::time_point today = system_clock::now();
// 			std::time_t tt = system_clock::to_time_t(today);
// 			cout << ctime(&tt) << e.what() << endl << endl;
// 		}
// 		catch (...)
// 		{
// 			cout << "Unkown Exception" << endl;
// 		}
// 	}

// 	return 0;
// }











// double Division(int a, int b)
// {
// 	// 当b == 0时抛出异常
// 	if (b == 0)
// 	{
// 		throw "Division by zero condition!";
// 	}
// 	return (double)a / (double)b;
// }

// void Func()
// {
// 	// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
// 	// 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再
// 	// 重新抛出去。
// 	int* array = new int[10];

// 	try 
// 	{
// 		int len, time;
// 		cin >> len >> time;
// 		cout << Division(len, time) << endl;
// 	}
// 	catch (...)
// 	{
// 		cout << "delete []" << array << endl;
// 		delete[] array;

// 		throw; // 异常重新抛出，捕获到什么抛出什么
// 	}

// 	// ...
// 	cout << "delete []" << array << endl;
// 	delete[] array;
// }

// void Func()
// {
// 	// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
// 	// 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再
// 	// 重新抛出去。
// 	// 
// 	// 更好解决方案是智能指针
// 	int* array1 = new int[10];
// 	int* array2 = new int[10];   // 抛异常呢

// 	try
// 	{
// 		int len, time;
// 		cin >> len >> time;
// 		cout << Division(len, time) << endl;
// 	}
// 	catch (...)
// 	{
// 		cout << "delete []" << array1 << endl;
// 		cout << "delete []" << array2 << endl;

// 		delete[] array1;
// 		delete[] array2;

// 		throw; // 异常重新抛出，捕获到什么抛出什么
// 	}

// 	// ...
// 	cout << "delete []" << array1 << endl;
// 	delete[] array1;

// 	cout << "delete []" << array2 << endl;
// 	delete[] array2;
// }


// int main()
// {
//     try
//     {
//         Func();
//     }
//     catch (const char* errmsg)
//     {
//         cout << errmsg << endl;
//     }
//     return 0;
// }














double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		throw "Division by zero condition!";
	}
	return (double)a / (double)b;
}


struct A
{
	~A() noexcept
	{
		cout << "~A()" << endl;
	}

	int _a1 = 0;
	int _a2 = 0;
};

template<class T>
class SmartPtr
{
public:
	// RAII
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		delete _ptr;
	}

	// 重载运算符，模拟指针的行为
	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};

void Func()
{
	// 更好解决方案是智能指针
	shared_ptr<A> sp1(new A);
	shared_ptr<A> sp2(new A);
	sp1->_a1++;
	sp1->_a2++;

	shared_ptr<A> sp3(sp1);

	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
}

int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知异常"<< endl;
	}

	return 0;
}